// 再度Miren
// 2622011721@qq.com
//导入config模块  配置信息 读取环境变量
const config = require('config')
// console.log(config.get('app').host);
const api = config.get('app').host
//设置接口
var axios = require('axios');
var qs = require('qs');
//每日脚本更新游戏文本内容
const { pool } = require('../PutArticle/model/MySQL');
const createPage = require('../Puppeteer/Puppeteer');
const log4js = require('../../reptile/Puppeteer/log/log4js.config');
const logger = log4js.getLogger("♦每日巡检");
const randomDelay = Math.floor(Math.random() * 3000) + 1000;

async function GoogelPlay_list(URL) {
  const { globalBrowser, page } = await createPage();
  try {
    await page.goto(URL, {
      timeout: 0,
    });
    if (true) {
      const result = await processPageData(page);
      return Promise.resolve(result);
    }
  } catch (error) {
    console.error('爬取失败:', error);
  } finally {
    //console.log('正在爬取 GoogelPlay 游戏内容...');
    await page.close();
    //console.log('关闭页面完成！');
    const pages = await globalBrowser.pages();
    console.log('当前浏览器标签页数量：' + pages.length);
  }
}

async function processPageData(page) {

  // 定义要保存的数据
  const dataArr = {
    game_name: '',
    star_rating: '',
    download_count: '',
    age_limit: '',
    description: 'Sample game description...',
    version: '1.0.1.2',
    update_date: '2023-07-30T00:00:00.000Z',
    android_version_required: '5.0 and up',
    interactive_elements: 'Users interact',
    release_date: null,
    developer: null,
    file_size: null,
    tags: JSON.stringify(['tag1', 'tag2']),
    class_name: 'tw.sonet.princessconnect',
    update_content: 'What\'s new in this version...',
  };

  // 从当前浏览器地址中截取ID后面的部分作为文件
  const url = page.url();
  console.log('当前 URL 是：' + url);
  const id = url.match(/\?id=(.*)/)[1];
  //console.log('游戏 ID 是：' + id);
  dataArr.class_name = id;

  // 获取游戏详情
  async function str() {
    try {

      await page.waitForTimeout(randomDelay);
      const elements = await page.$$('h2.XfZNbf');
      for (const element of elements) {
        const text = await element.evaluate(node => node.textContent);
        if (text === '游戏简介' || text === '關於本遊戲' || text === '遊戲簡介' || text === '关于此应用' || text === '關於此應用程式') {
          const parentElement = await element.evaluateHandle(node => node.parentElement);
          const divSibling = await parentElement.evaluateHandle(node => node.nextElementSibling);
          const divText = await divSibling.evaluate(node => node.textContent);
          //console.log(divText);
          await divSibling.click(); // 点击元素
          await Promise.all([
            a()
          ]);

        } else {
          // console.log('正在查找...');
        }
      }

      async function a() {
        // 使用 page.evaluate 来获取匹配属性的 div 元素
        const divElement = await page.evaluate(() => {
          const divs = document.querySelectorAll('div[jsname="rZHESd"]');
          return divs.length > 0 ? divs[0].outerHTML : null;
        });
        if (!divElement) {
          console.log('未找到匹配的 div 元素');
        }
        await page.waitForSelector('div[jsname="rZHESd"]');
        
        async function game_version() {
          const version = await page.evaluate(() => {
            const div = document.querySelector('div[jsname="rZHESd"]');
            if (div) {
              const cons = div.querySelector('div.reAt0');

              return cons ? cons.innerHTML : null;

            } else {
              //console.log('meiyou1')
            }
          });
          //console.log('版本号:', version);
          dataArr.version = version;
        }
        await game_version()
        //  await page.waitForTimeout(99000);
  
        const how = await getUrlversion(dataArr.class_name, dataArr.version)

        // console.log({ how })
        if (how) {
          logger.info('游戏名字:', dataArr.game_name, '版本号不相同，爬取')
          console.log("版本号不相同，爬取")
          // await page.waitForTimeout(500000); // 等待50秒

          //游戏名称
          async function game_name() {
            const game_name = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (!div) {
                console.log('未找到游戏名')
              }
              const cons = div.querySelector('h5.xzVNx');
              return cons ? cons.textContent : null;
            });
            //console.log('游戏名字:', game_name);
            logger.info(`游戏名: ${game_name}-${dataArr.class_name}`)
            dataArr.game_name = game_name;
          }
          await game_name()
          async function paragraphTexts() {
            const paragraphTexts = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const cons = div.querySelector('div.fysCi');
                if (cons) {
                  const firstInnerDiv = cons.querySelector('div'); // 获取第一个 div 元素
                  return firstInnerDiv ? firstInnerDiv.innerHTML : null;
                }
              } else {
                //console.log('meiyou1')
              }
            });
            //console.log('游戏简介:', paragraphTexts);
            dataArr.update_content = paragraphTexts;
          }
          await paragraphTexts()

          async function game_update_date() {

            const update_date = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const reAt0Elements = div.querySelectorAll('div.reAt0'); // 获取所有匹配的reAt0元素
                if (reAt0Elements.length >= 2) { // 检查是否至少有两个匹配的元素
                  return reAt0Elements[1].textContent; // 获取第二个匹配元素的文本内容
                }
              } else {
                //console.log('meiyou1')
              }
              return null; // 如果没有找到匹配的元素或不足两个匹配元素，返回null
            });
            //console.log('更新日期:', update_date);
            const inputDateString = update_date
            // 使用正则表达式提取年、月、日
            const match = inputDateString.match(/(\d{4})年(\d{1,2})月(\d{1,2})日/);

            if (match) {
              const year = parseInt(match[1], 10);
              const month = parseInt(match[2], 10);
              const day = parseInt(match[3], 10);

              // 创建一个新的Date对象，注意月份要减1
              const outputDate = new Date(year, month - 1, day);

              // 格式化为ISO日期字符串
              const outputDateString = outputDate.toISOString();
              //console.log(outputDateString);
              dataArr.update_date = outputDateString;
            } else {
              //console.log('无法解析日期字符串。');
            }

          }
          await game_update_date()

          async function game_android_version_required() {
            const android_version_required = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const reAt0Elements = div.querySelectorAll('div.reAt0'); // 获取所有匹配的reAt0元素
                if (reAt0Elements.length >= 2) { // 检查是否至少有两个匹配的元素
                  return reAt0Elements[2].textContent; // 获取第二个匹配元素的文本内容
                }
              } else {
                //console.log('meiyou1')
              }
              return null; // 如果没有找到匹配的元素或不足两个匹配元素，返回null
            });
            //console.log('Android 系统版本要求:', android_version_required);
            dataArr.android_version_required = android_version_required;
          }
          await game_android_version_required()

          async function download_count() {
            const download_count = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const reAt0Elements = div.querySelectorAll('div.reAt0'); // 获取所有匹配的reAt0元素
                if (reAt0Elements.length >= 2) { // 检查是否至少有两个匹配的元素
                  return reAt0Elements[3].textContent; // 获取第二个匹配元素的文本内容
                }
              } else {
                //console.log('meiyou1')
              }
              return null; // 如果没有找到匹配的元素或不足两个匹配元素，返回null
            });
            //console.log('下载次数：', download_count);
            dataArr.download_count = download_count.replace(/次下载/g, '');
          }
          await download_count()

          async function description() {
            const description = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const reAt0Elements = div.querySelectorAll('div.reAt0'); // 获取所有匹配的reAt0元素
                if (reAt0Elements.length >= 2) { // 检查是否至少有两个匹配的元素
                  return reAt0Elements[4].textContent; // 获取第二个匹配元素的文本内容
                }
              } else {
                //console.log('meiyou1')
              }
              return null; // 如果没有找到匹配的元素或不足两个匹配元素，返回null
            });
            //console.log('应用内购商品', description);
            dataArr.description = description;
          }
          await description()

          async function age_limit() {
            try {
              const age_limit = await page.evaluate(() => {
                const element = document.querySelector('span[itemprop="contentRating"] > span');
                if (element) {
                  return element.textContent.trim(); // 获取元素的文本内容并去除首尾空白
                } else {
                  return null; // 如果找不到元素，则返回 null
                }
              });
              dataArr.age_limit = age_limit
            } catch (error) {
              console.error('在 age_limit 函数中发生错误:', error);
              return null; // 如果发生错误，返回 null
            }
          }
          await age_limit()
          async function interactive_elements() {
            const interactive_elements = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const reAt0Elements = div.querySelectorAll('div.reAt0'); // 获取所有匹配的reAt0元素
                if (reAt0Elements.length >= 7) { // 检查是否至少有七个匹配的元素
                  return reAt0Elements[6].textContent; // 获取第七个匹配元素的文本内容
                }
              } else {
                //console.log('meiyou1')
              }
              return null; // 如果没有找到匹配的元素或不足七个匹配元素，返回null
            });
            //console.log('互动元素：', interactive_elements);
            dataArr.interactive_elements = interactive_elements;
          }

          await interactive_elements();

          async function release_date() {
            const release_date = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const reAt0Elements = div.querySelectorAll('div.reAt0'); // 获取所有匹配的reAt0元素
                if (reAt0Elements.length >= 2) { // 检查是否至少有两个匹配的元素
                  if (reAt0Elements[8]) {
                    return reAt0Elements[8].textContent; // 获取第二个匹配元素的文本内容
                  } else {
                    return null
                  }

                }
              } else {
                //console.log('meiyou1')
              }
              return null; // 如果没有找到匹配的元素或不足两个匹配元素，返回null
            });
            //console.log('发布日期', release_date);
            dataArr.release_date = release_date;
          }
          await release_date()

          async function developer() {
            const developer = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const reAt0Elements = div.querySelectorAll('div.reAt0'); // 获取所有匹配的reAt0元素
                if (reAt0Elements.length >= 2) { // 检查是否至少有两个匹配的元素
                  if (reAt0Elements[9]) {
                    return reAt0Elements[9].textContent; // 获取第二个匹配元素的文本内容
                  } else {
                    return null
                  }

                }
              } else {
                //console.log('meiyou1')
              }
              return null; // 如果没有找到匹配的元素或不足两个匹配元素，返回null
            });
            //console.log('开发厂商', developer);
            dataArr.developer = developer;
          }
          await developer()

          async function game_size() {
            const file_size = await page.evaluate(() => {
              const div = document.querySelector('div[jsname="rZHESd"]');
              if (div) {
                const reAt0Elements = div.querySelectorAll('div.reAt0'); // 获取所有匹配的reAt0元素
                if (reAt0Elements.length >= 2) { // 检查是否至少有两个匹配的元素
                  if (reAt0Elements[11]) {
                    return reAt0Elements[11].textContent; // 获取第二个匹配元素的文本内容
                  }

                }
              } else {
                //console.log('meiyou1')
              }
              return null; // 如果没有找到匹配的元素或不足两个匹配元素，返回null
            });
            //console.log('下载大小：', file_size);
            dataArr.file_size = file_size;
          }
          await game_size()

          async function main() {
            try {
              const result = await GoogelPlay(dataArr);
              console.log(result);
              return Promise.resolve(result);
              // 这里可以处理返回的结果
            } catch (error) {
              console.error('发生错误:', error);
            }
          }

          // console.log(dataArr);
          const result = await main();
          return Promise.resolve(result);

        } else {
          return Promise.resolve('完成');
        }

        async function GoogelPlay(dataArr) {

          var data = {
            "gameName": dataArr.game_name,
            "packageName": dataArr.class_name,
            "versionNumber": dataArr.version,
            "versionDate": dataArr.update_date,
            "uploadDate": new Date().toISOString().split('T')[0]
          }
            ;

          var config = {
            method: 'post',
            url: `${api}/add_Update_Required`,
            headers: {
              'User-Agent': 'Apifox/1.0.0 (https://apifox.com)',
              'Content-Type': 'application/json'
            },
            data: data
          };

          axios(config)
            .then(function (response) {
              logger.info('游戏名字:', dataArr.game_name, '✔已记录！')
              console.log(JSON.stringify(response.data));
            })
            .catch(function (error) {
              console.log(error);
            });

          // console.log(dataArr); // 在控制台中打印接收到的数组
          try {
            const connection = await pool.getConnection();

            // 查询数据库中是否已存在对应的数据
            const [rows] = await connection.execute('SELECT * FROM GP_Game_Content WHERE class_name = ?', [dataArr.class_name]);

            if (rows.length > 0) {
              // 如果数据已存在，执行更新操作
              const updateQuery = `
                    UPDATE GP_Game_Content
                    SET game_name = ?, star_rating = ?, download_count = ?, age_limit = ?, description = ?,
                    version = ?, update_date = ?, android_version_required = ?, interactive_elements = ?,
                    release_date = ?, developer = ?, file_size = ?, tags = ?, update_content = ?
                    WHERE class_name = ?
                  `;

              const updateValues = [
                dataArr.game_name, dataArr.star_rating, dataArr.download_count, dataArr.age_limit, dataArr.description,
                dataArr.version, dataArr.update_date, dataArr.android_version_required, dataArr.interactive_elements,
                dataArr.release_date, dataArr.developer, dataArr.file_size, JSON.stringify(dataArr.tags), dataArr.update_content,
                dataArr.class_name,
              ];

              await connection.execute(updateQuery, updateValues);
              logger.info('游戏名字:', dataArr.game_name, '数据已更新！')
              console.log('数据已更新！');
            } else {
              // 如果数据不存在，执行插入操作
              const insertQuery = `
                    INSERT INTO GP_Game_Content
                    (game_name, star_rating, download_count, age_limit, description, version, update_date,
                    android_version_required, interactive_elements, release_date, developer, file_size, tags,
                    update_content, class_name)
                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                  `;

              const insertValues = [
                dataArr.game_name, dataArr.star_rating, dataArr.download_count, dataArr.age_limit, dataArr.description,
                dataArr.version, dataArr.update_date, dataArr.android_version_required, dataArr.interactive_elements,
                dataArr.release_date, dataArr.developer, dataArr.file_size, JSON.stringify(dataArr.tags), dataArr.update_content,
                dataArr.class_name,
              ];

              await connection.execute(insertQuery, insertValues);
              logger.info('游戏名字:', dataArr.game_name, '数据已插入！')
              console.log('数据已插入！');
            }

            connection.release();
            return '完成';
          } catch (error) {
            console.error('数据库操作出错:', error);
          }


        };
        async function getUrlversion(class_name, This_version) {
          try {
            const response = await axios.get(`${api}/getGameInfoByClassName?class_name=${class_name}`, {
              headers: {
                'User-Agent': 'Apifox/1.0.0 (https://apifox.com)'
              }
            });

            const remoteVersion = response.data.data.version;
            logger.info(response.data);
            // console.log("库内版本为:", remoteVersion);
            // console.log("爬取的版本为", This_version);
            logger.info('版本:', remoteVersion, This_version)
            console.log('版本:', remoteVersion, This_version)

            // 判断版本是否一致
            if (remoteVersion !== This_version) {
              return true; // 版本不一致
            } else {
              return false; // 版本一致
            }
          } catch (error) {
            console.error("Error:", error);
            throw error; // 抛出错误，让调用方处理
          }
        }

        // 



      }

      //console.log('自运行函数执行完毕');
    } catch (error) {
      console.error('发生错误:', error);
    }
  };
  // 获取游戏标签
  async function tagsList() {
    // 使用 page.evaluate 在页面上下文中执行操作
    const spanTexts = await page.evaluate(() => {
      const divElements = document.querySelectorAll('.Uc6QCc'); // 获取所有指定 class 的 div 元素
      const spanTextsArray = [];

      divElements.forEach(divElement => {
        const spanElements = divElement.querySelectorAll('span'); // 获取每个 div 元素下的所有 span 元素
        spanElements.forEach(spanElement => {
          const text = spanElement.textContent.trim(); // 获取每个 span 元素的文本并去除首尾空格
          spanTextsArray.push(text);
        });
      });

      return spanTextsArray;
    });

    // //console.log(spanTexts); // 打印 span 元素的文本数组
    dataArr.tags = spanTexts;
  }
  // 获取游戏星级
  async function starRating() {
    // 使用 page.evaluate 在页面上下文中执行操作
    const divText = await page.evaluate(() => {
      const divElement = document.querySelector('.TT9eCd'); // 获取具有指定 class 的 div 元素
      return divElement ? divElement.textContent.trim() : null;
    });

    if (divText) {
      const starRating = divText.match(/\d+\.\d+/);
      if (starRating) {
        // //console.log('提取的星级评分:', starRating[0]);
        dataArr.star_rating = starRating[0]
      }
    } else {
      //console.log('未找到具有 class "TT9eCd" 的 div 元素。');
    }
  }

  await Promise.all([
    // 等待异步操作完成
    str(),
    tagsList(),
    starRating()
    // ...
  ]);


}

// GoogelPlay_list('https://play.google.com/store/apps/details?id=com.zigzagame.tokyodebunker')
module.exports = GoogelPlay_list;
